import java.util.ArrayList;
import java.util.HashMap;
import java.util.Scanner;
import java.util.Vector;

public class FindDeadLock {

    public static class Node {
        int pid;
        HashMap<Integer, Integer> hasResource = new HashMap<>();
        HashMap<Integer, Integer> needResource = new HashMap<>();
    }

    // 检查是否存在可以完成的进程
    public static int check(Vector<Node> nodes, int[] resource, int m) {
        for (int i = 0; i < nodes.size(); i++) {
            Node node = nodes.get(i);
            if (node.pid == -1) continue; // 已完成的进程跳过

            boolean canComplete = true;
            // 检查该进程是否能满足所有资源需求
            for (int j = 1; j <= m; j++) {
                int need = node.needResource.getOrDefault(j, 0);
                // 如果需要的资源超过系统现有资源，则不能完成
                if (need > resource[j]) {
                    canComplete = false;
                    break;
                }
            }

            if (canComplete) return i; // 找到可以完成的进程
        }
        return -1; // 没有可以完成的进程
    }

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt(), m = in.nextInt(); // n个进程，m种资源

        int[] resource = new int[m + 1]; // 系统可用资源，索引从1开始
        for (int i = 1; i <= m; i++) {
            resource[i] = in.nextInt();
        }

        // 读取每个进程的资源占有和需求情况
        Vector<Node> nodes = new Vector<>();
        for (int i = 1; i <= n; i++) {
            Node node = new Node();
            node.pid = i;

            // 读取已占有资源
            int hasCount = in.nextInt();
            for (int j = 0; j < hasCount; j++) {
                int r = in.nextInt(); // 资源类型
                int count = in.nextInt(); // 资源数量
                node.hasResource.put(r, count);
            }

            // 读取需要的资源
            int needCount = in.nextInt();
            for (int j = 0; j < needCount; j++) {
                int r = in.nextInt();
                int count = in.nextInt();
                node.needResource.put(r, count);
            }

            nodes.add(node);
        }

        // 模拟资源分配过程，直到没有可以完成的进程
        int processId = check(nodes, resource, m);
        while (processId != -1) {
            Node node = nodes.get(processId);
            // 释放该进程持有的资源
            for (int i = 1; i <= m; i++) {
                if (node.hasResource.containsKey(i)) {
                    resource[i] += node.hasResource.get(i);
                }
            }
            System.out.println("进程" + node.pid + "完成，释放资源");
            node.pid = -1; // 标记为已完成
            processId = check(nodes, resource, m); // 重新检查
        }

        // 收集所有未完成的进程（死锁进程）
        ArrayList<Integer> deadlocked = new ArrayList<>();
        for (Node node : nodes) {
            if (node.pid != -1) {
                deadlocked.add(node.pid);
            }
        }

        // 输出死锁结果
        System.out.println("死锁进程数量: " + deadlocked.size());
        if (!deadlocked.isEmpty()) {
            System.out.print("死锁进程ID: ");
            for (int i = 0; i < deadlocked.size(); i++) {
                if (i != 0) System.out.print(" ");
                System.out.print(deadlocked.get(i));
            }
            System.out.println();
        }
    }
}

/*
*
 2 2
 0 1
 1 1 2   已有
 1 2 1   缺少
 2 1 1 2 1  已有
 1 1 1   缺少

* 2 2
* 0 0
* 1 1 1
* 1 2 1
* 1 2 1
* 1 1 1   死锁
* */